import _ from 'underscore'

/**
 * 判断某个值是否在数组中,返回布尔，单纯数组
 * @param arr
 * @param val
 * @returns {boolean}
 * 例：isInArr([1,2,3],2) ==>  true
 */
export let isInArr = (arr, val) => {
  if (!_.isArray(arr)) return null
  for (let i = 0; i < arr.length; i++) {
    if (arr[i] === val) return true
  }
  return false
}

/**
 * 判断某个值在数组中的位置,返回序列，数字型
 * @param arr
 * @param val
 * @returns {number}
 * 例：
 */
export let indexOf = (arr, val) => {
  if (!_.isArray(arr)) return null
  for (let i = 0; i < arr.length; i++) {
    if (arr[i] === val) return i
  }
  return -1
}

/**
 * 将数组转成含有对象的数组
 * @param arr
 * @param name 变成数组的键名
 * @returns {Array}
 */
export let toObj = (arr, name) => {
  if (!_.isArray(arr)) return null
  if (!name) return null
  let str = []
  arr.forEach(c => str.push({ [name]: c }))
  return str
}

/**
 * 数组中是否有某个对象（只要一个kek相同,就返回真）
 * @param arr
 * @param obj 对象
 * @returns {boolean}
 */
export let hasObj = (arr, obj) => {
  if (!_.isArray(arr)) return null
  if (!_.isObject(obj)) return null
  let tarr = _.find(arr, x => x[_.keys(obj)] == _.values(obj))
  return _.isObject(tarr)
}
/**
 * 数组中是否有某个对象的位置（只要一个kek相同,就返回index）
 * @param arr
 * @param obj
 * @returns {*} 返回索引或-1
 */
export let objIndex = (arr, obj) => {
  if (!_.isArray(arr)) return null
  if (!_.isObject(obj)) return null
  let index = arr.indexOf(findObj(arr, obj))
  if (index >= 0) return index
  return -1
}

/**
 * 数组中找到某一个对象，返回一个对象
 * @param obj 返回一个对象
 * @param arr
 */
export let findObj = (arr, obj) =>
  _.find(arr, x => {
    if (!_.isArray(arr)) return null
    if (!_.isObject(obj)) return null
    return x[_.keys(obj)] == _.values(obj)
  })

/**
 * 排除数组中的对象Obj，返回一个数组
 * @param arr
 * @param obj
 * @returns {Array}
 */
export let rejectObj = (arr, obj) => {
  if (!_.isArray(arr)) return null
  if (!_.isObject(obj)) return null
  return _.reject(arr, x => x[_.keys(obj)] == _.values(obj))
}

/**
 * 过滤数组中的对象Obj，返回一个数组
 * @param obj
 * @param arr
 * @returns {Array}
 */
export let filterObj = (arr, obj) => {
  if (!_.isArray(arr)) return null
  if (!_.isObject(obj)) return null
  return _.filter(arr, x => x[_.keys(obj)] == _.values(obj))
}

/**
 * 数组中替换某个Obj，返回一个数组
 * @param arr
 * @param obj
 * @param obj2
 * @returns {*}
 */
export let replaceObj = (arr, obj, obj2) => {
  if (!_.isArray(arr)) return null
  if (!_.isObject(obj)) return null
  if (!_.isObject(obj2)) return null
  let index = arr.indexOf(findObj(arr, obj))
  if (index >= 0) {
    arr.splice(index, 1)
    return [...arr, obj2]
  }
  return -1
}
/**
 * 随机从数组中取一个值
 * @returns {*}
 * @private
 */
export let getRandomObj = arr => {
  if (!_.isArray(arr)) return null
  return arr[Math.floor(Math.random() * arr.length)]
}

/**
 * 数组去重
 * @returns {Array}
 * @private
 */
export let arrOnly = arr => {
  if (!_.isArray(arr)) return null
  return _.uniq(arr)
}
/**
 * 数组去重
 param {Array} arr-待去重数组
 unique([1,2,3,4,2,1,2,3,4,5])
 result: [1, 2, 3, 4, 5]
 */
export let unique = arr => {
  if (!_.isArray(arr)) return null
  //es6
  return [...new Set(arr)]
}
/**
 * @description 数组顺序打乱
 * @param arr
 * @return {Array.<T>}
 * upsetArr([1,2,3,4,5,6,7,8,9,0])
 result:  [7, 1, 3, 2, 4, 6, 8, 9, 0, 5]
 */
export let upsetArr = arr => {
  if (!_.isArray(arr)) return null
  let j, tempitem
  for (let i = 0; i < arr.length; i++) {
    j = Math.floor(Math.random() * i)
    tempitem = arr[i]
    arr[i] = arr[j]
    arr[j] = tempitem
  }
  return arr
}

/**
 * 从json数组中找到每一项的key对应的值，返回一个数组
 * @param key
 * @param arr
 * @returns {*|Observable}
 */
export let keyToArr = (arr, key) => {
  if (!_.isArray(arr)) return null
  return _.pluck(arr, key)
}

/**
 * @description 数组最大值（数值数组）
 * @param arr
 */
export let maxArr = arr => {
  if (!_.isArray(arr)) return null
  return Math.max.apply(null, arr)
}
/**
 * @description 数组最小值（数值数组）
 * @param arr
 */
export let minArr = arr => {
  if (!_.isArray(arr)) return null
  return Math.min.apply(null, arr)
}
/**
 * 数组去掉无效的值
 * @param arr
 * @return array
 */
export let rejectBad = arr => {
  if (!_.isArray(arr)) return null
  return _.compact(arr)
}
